home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Comm / AmiTCP30b2.lha / src / rpclib / svc.c < prev    next >
C/C++ Source or Header  |  1994-03-09  |  12KB  |  512 lines
  1. /*
  2.  * $Id: svc.c,v 1.2 1993/11/10 02:45:05 jraja Exp $
  3.  *
  4.  * $Log: svc.c,v $
  5.  * Revision 1.2  1993/11/10  02:45:05  jraja
  6.  * Fixed includes, ANSI prototypes.
  7.  * Added ffs() function.
  8.  * Added clearing of allocated pointer array on AMIGA (not needed on UNIX?).
  9.  *
  10.  */
  11. /* @(#)svc.c    2.4 88/08/11 4.0 RPCSRC; from 1.44 88/02/08 SMI */
  12. /*
  13.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  14.  * unrestricted use provided that this legend is included on all tape
  15.  * media and as a part of the software program in whole or part.  Users
  16.  * may copy or modify Sun RPC without charge, but are not authorized
  17.  * to license or distribute it to anyone else except as part of a product or
  18.  * program developed by the user.
  19.  * 
  20.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  21.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  22.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  23.  * 
  24.  * Sun RPC is provided with no support and without any obligation on the
  25.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  26.  * modification or enhancement.
  27.  * 
  28.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  29.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  30.  * OR ANY PART THEREOF.
  31.  * 
  32.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  33.  * or profits or other special, indirect and consequential damages, even if
  34.  * Sun has been advised of the possibility of such damages.
  35.  * 
  36.  * Sun Microsystems, Inc.
  37.  * 2550 Garcia Avenue
  38.  * Mountain View, California  94043
  39.  */
  40. #if !defined(lint) && defined(SCCSIDS)
  41. static char sccsid[] = "@(#)svc.c 1.41 87/10/13 Copyr 1984 Sun Micro";
  42. #endif
  43.  
  44. /*
  45.  * svc.c, Server-side remote procedure call interface.
  46.  *
  47.  * There are two sets of procedures here.  The xprt routines are
  48.  * for handling transport handles.  The svc routines handle the
  49.  * list of service routines.
  50.  *
  51.  * Copyright (C) 1984, Sun Microsystems, Inc.
  52.  */
  53.  
  54. #include <sys/param.h>
  55. #include <errno.h>
  56. #include <rpc/rpc.h>
  57. #include <rpc/pmap_clnt.h>
  58. #include <sys/syslog.h>
  59.  
  60. #ifdef FD_SETSIZE
  61. static SVCXPRT **xports;
  62. #else
  63. #define NOFILE 32
  64.  
  65. static SVCXPRT *xports[NOFILE];
  66. #endif /* def FD_SETSIZE */
  67.  
  68. #ifdef FD_SETSIZE
  69. /*
  70.  * ffs() copied directly from bsdss/server/kern/subr_xxx.c
  71.  */
  72. static __inline int ffs(register long mask)
  73. {
  74.   register int bit;
  75.  
  76.   if (!mask)
  77.     return(0);
  78.   for (bit = 1;; ++bit) {
  79.     if (mask&0x01)
  80.       return(bit);
  81.     mask >>= 1;
  82.   }
  83.   /* NOT REACHED */
  84. }
  85. #endif /* def FD_SETSIZE */
  86.  
  87. #define NULL_SVC ((struct svc_callout *)0)
  88. #define    RQCRED_SIZE    400        /* this size is excessive */
  89.  
  90. static struct svc_callout *
  91. svc_find(u_long prog, u_long vers, struct svc_callout **prev);
  92.  
  93. /*
  94.  * The services list
  95.  * Each entry represents a set of procedures (an rpc program).
  96.  * The dispatch routine takes request structs and runs the
  97.  * appropriate procedure.
  98.  */
  99. static struct svc_callout {
  100.     struct svc_callout *sc_next;
  101.     u_long            sc_prog;
  102.     u_long            sc_vers;
  103.     void            (* sc_dispatch)(struct svc_req *, SVCXPRT *);
  104. } *svc_head;
  105.  
  106. static struct svc_callout *svc_find();
  107.  
  108. /* ***************  SVCXPRT related stuff **************** */
  109.  
  110. /*
  111.  * Activate a transport handle.
  112.  */
  113. void
  114. xprt_register(xprt)
  115.     SVCXPRT *xprt;
  116. {
  117.     register int sock = xprt->xp_sock;
  118.  
  119. #ifdef FD_SETSIZE
  120.     if (xports == NULL) {
  121.         xports = (SVCXPRT **)
  122.             mem_alloc(FD_SETSIZE * sizeof(SVCXPRT *));
  123. #ifdef AMIGA /* allocated area MUST be cleared */
  124.         bzero(xports, FD_SETSIZE * sizeof(SVCXPRT *));
  125. #endif
  126.     }
  127.     if (sock < _rpc_dtablesize()) {
  128.         xports[sock] = xprt;
  129.         FD_SET(sock, &svc_fdset);
  130.     }
  131. #else
  132.     if (sock < NOFILE) {
  133.         xports[sock] = xprt;
  134.         svc_fds |= (1 << sock);
  135.     }
  136. #endif /* def FD_SETSIZE */
  137.  
  138. }
  139.  
  140. /*
  141.  * De-activate a transport handle. 
  142.  */
  143. void
  144. xprt_unregister(xprt) 
  145.     SVCXPRT *xprt;
  146. { 
  147.     register int sock = xprt->xp_sock;
  148.  
  149. #ifdef FD_SETSIZE
  150.     if ((sock < _rpc_dtablesize()) && (xports[sock] == xprt)) {
  151.         xports[sock] = (SVCXPRT *)0;
  152.         FD_CLR(sock, &svc_fdset);
  153.     }
  154. #else
  155.     if ((sock < NOFILE) && (xports[sock] == xprt)) {
  156.         xports[sock] = (SVCXPRT *)0;
  157.         svc_fds &= ~(1 << sock);
  158.     }
  159. #endif /* def FD_SETSIZE */
  160. }
  161.  
  162.  
  163. /* ********************** CALLOUT list related stuff ************* */
  164.  
  165. /*
  166.  * Add a service program to the callout list.
  167.  * The dispatch routine will be called when a rpc request for this
  168.  * program number comes in.
  169.  */
  170. bool_t
  171. svc_register(xprt, prog, vers, dispatch, protocol)
  172.     SVCXPRT *xprt;
  173.     u_long prog;
  174.     u_long vers;
  175.     void (* dispatch)(struct svc_req *, SVCXPRT *);
  176.     int protocol;
  177. {
  178.     struct svc_callout *prev;
  179.     register struct svc_callout *s;
  180.  
  181.     if ((s = svc_find(prog, vers, &prev)) != NULL_SVC) {
  182.         if (s->sc_dispatch == dispatch)
  183.             goto pmap_it;  /* he is registering another xptr */
  184.         return (FALSE);
  185.     }
  186.     s = (struct svc_callout *)mem_alloc(sizeof(struct svc_callout));
  187.     if (s == (struct svc_callout *)0) {
  188.         return (FALSE);
  189.     }
  190.     s->sc_prog = prog;
  191.     s->sc_vers = vers;
  192.     s->sc_dispatch = dispatch;
  193.     s->sc_next = svc_head;
  194.     svc_head = s;
  195. pmap_it:
  196.     /* now register the information with the local binder service */
  197.     if (protocol) {
  198.         return (pmap_set(prog, vers, protocol, xprt->xp_port));
  199.     }
  200.     return (TRUE);
  201. }
  202.  
  203. /*
  204.  * Remove a service program from the callout list.
  205.  */
  206. void
  207. svc_unregister(prog, vers)
  208.     u_long prog;
  209.     u_long vers;
  210. {
  211.     struct svc_callout *prev;
  212.     register struct svc_callout *s;
  213.  
  214.     if ((s = svc_find(prog, vers, &prev)) == NULL_SVC)
  215.         return;
  216.     if (prev == NULL_SVC) {
  217.         svc_head = s->sc_next;
  218.     } else {
  219.         prev->sc_next = s->sc_next;
  220.     }
  221.     s->sc_next = NULL_SVC;
  222.     mem_free((char *) s, (u_int) sizeof(struct svc_callout));
  223.     /* now unregister the information with the local binder service */
  224.     (void)pmap_unset(prog, vers);
  225. }
  226.  
  227. /*
  228.  * Search the callout list for a program number, return the callout
  229.  * struct.
  230.  */
  231. static struct svc_callout *
  232. svc_find(u_long prog, u_long vers, struct svc_callout **prev)
  233. {
  234.     register struct svc_callout *s, *p;
  235.  
  236.     p = NULL_SVC;
  237.     for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  238.         if ((s->sc_prog == prog) && (s->sc_vers == vers))
  239.             goto done;
  240.         p = s;
  241.     }
  242. done:
  243.     *prev = p;
  244.     return (s);
  245. }
  246.  
  247. /* ******************* REPLY GENERATION ROUTINES  ************ */
  248.  
  249. /*
  250.  * Send a reply to an rpc request
  251.  */
  252. bool_t
  253. svc_sendreply(xprt, xdr_results, xdr_location)
  254.     register SVCXPRT *xprt;
  255.     xdrproc_t xdr_results;
  256.     caddr_t xdr_location;
  257. {
  258.     struct rpc_msg rply; 
  259.  
  260.     rply.rm_direction = REPLY;  
  261.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  262.     rply.acpted_rply.ar_verf = xprt->xp_verf; 
  263.     rply.acpted_rply.ar_stat = SUCCESS;
  264.     rply.acpted_rply.ar_results.where = xdr_location;
  265.     rply.acpted_rply.ar_results.proc = xdr_results;
  266.     return (SVC_REPLY(xprt, &rply)); 
  267. }
  268.  
  269. /*
  270.  * No procedure error reply
  271.  */
  272. void
  273. svcerr_noproc(xprt)
  274.     register SVCXPRT *xprt;
  275. {
  276.     struct rpc_msg rply;
  277.  
  278.     rply.rm_direction = REPLY;
  279.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  280.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  281.     rply.acpted_rply.ar_stat = PROC_UNAVAIL;
  282.     SVC_REPLY(xprt, &rply);
  283. }
  284.  
  285. /*
  286.  * Can't decode args error reply
  287.  */
  288. void
  289. svcerr_decode(xprt)
  290.     register SVCXPRT *xprt;
  291. {
  292.     struct rpc_msg rply; 
  293.  
  294.     rply.rm_direction = REPLY; 
  295.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  296.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  297.     rply.acpted_rply.ar_stat = GARBAGE_ARGS;
  298.     SVC_REPLY(xprt, &rply); 
  299. }
  300.  
  301. /*
  302.  * Some system error
  303.  */
  304. void
  305. svcerr_systemerr(xprt)
  306.     register SVCXPRT *xprt;
  307. {
  308.     struct rpc_msg rply; 
  309.  
  310.     rply.rm_direction = REPLY; 
  311.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  312.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  313.     rply.acpted_rply.ar_stat = SYSTEM_ERR;
  314.     SVC_REPLY(xprt, &rply); 
  315. }
  316.  
  317. /*
  318.  * Authentication error reply
  319.  */
  320. void
  321. svcerr_auth(xprt, why)
  322.     SVCXPRT *xprt;
  323.     enum auth_stat why;
  324. {
  325.     struct rpc_msg rply;
  326.  
  327.     rply.rm_direction = REPLY;
  328.     rply.rm_reply.rp_stat = MSG_DENIED;
  329.     rply.rjcted_rply.rj_stat = AUTH_ERROR;
  330.     rply.rjcted_rply.rj_why = why;
  331.     SVC_REPLY(xprt, &rply);
  332. }
  333.  
  334. /*
  335.  * Auth too weak error reply
  336.  */
  337. void
  338. svcerr_weakauth(xprt)
  339.     SVCXPRT *xprt;
  340. {
  341.  
  342.     svcerr_auth(xprt, AUTH_TOOWEAK);
  343. }
  344.  
  345. /*
  346.  * Program unavailable error reply
  347.  */
  348. void 
  349. svcerr_noprog(xprt)
  350.     register SVCXPRT *xprt;
  351. {
  352.     struct rpc_msg rply;  
  353.  
  354.     rply.rm_direction = REPLY;   
  355.     rply.rm_reply.rp_stat = MSG_ACCEPTED;  
  356.     rply.acpted_rply.ar_verf = xprt->xp_verf;  
  357.     rply.acpted_rply.ar_stat = PROG_UNAVAIL;
  358.     SVC_REPLY(xprt, &rply);
  359. }
  360.  
  361. /*
  362.  * Program version mismatch error reply
  363.  */
  364. void  
  365. svcerr_progvers(xprt, low_vers, high_vers)
  366.     register SVCXPRT *xprt; 
  367.     u_long low_vers;
  368.     u_long high_vers;
  369. {
  370.     struct rpc_msg rply;
  371.  
  372.     rply.rm_direction = REPLY;
  373.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  374.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  375.     rply.acpted_rply.ar_stat = PROG_MISMATCH;
  376.     rply.acpted_rply.ar_vers.low = low_vers;
  377.     rply.acpted_rply.ar_vers.high = high_vers;
  378.     SVC_REPLY(xprt, &rply);
  379. }
  380.  
  381. /* ******************* SERVER INPUT STUFF ******************* */
  382.  
  383. /*
  384.  * Get server side input from some transport.
  385.  *
  386.  * Statement of authentication parameters management:
  387.  * This function owns and manages all authentication parameters, specifically
  388.  * the "raw" parameters (msg.rm_call.cb_cred and msg.rm_call.cb_verf) and
  389.  * the "cooked" credentials (rqst->rq_clntcred).
  390.  * However, this function does not know the structure of the cooked
  391.  * credentials, so it make the following assumptions: 
  392.  *   a) the structure is contiguous (no pointers), and
  393.  *   b) the cred structure size does not exceed RQCRED_SIZE bytes. 
  394.  * In all events, all three parameters are freed upon exit from this routine.
  395.  * The storage is trivially management on the call stack in user land, but
  396.  * is mallocated in kernel land.
  397.  */
  398.  
  399. void
  400. svc_getreq(rdfds)
  401.     int rdfds;
  402. {
  403. #ifdef FD_SETSIZE
  404.     fd_set readfds;
  405.  
  406.     FD_ZERO(&readfds);
  407.     readfds.fds_bits[0] = rdfds;
  408.     svc_getreqset(&readfds);
  409. #else
  410.     int readfds = rdfds & svc_fds;
  411.  
  412.     svc_getreqset(&readfds);
  413. #endif /* def FD_SETSIZE */
  414. }
  415.  
  416. void
  417. svc_getreqset(readfds)
  418. #ifdef FD_SETSIZE
  419.     fd_set *readfds;
  420. {
  421. #else
  422.     int *readfds;
  423. {
  424.     int readfds_local = *readfds;
  425. #endif /* def FD_SETSIZE */
  426.     enum xprt_stat stat;
  427.     struct rpc_msg msg;
  428.     int prog_found;
  429.     u_long low_vers;
  430.     u_long high_vers;
  431.     struct svc_req r;
  432.     register SVCXPRT *xprt;
  433.     register u_long mask;
  434.     register int bit;
  435.     register u_long *maskp;
  436.     register int setsize;
  437.     register int sock;
  438.     char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE];
  439.     msg.rm_call.cb_cred.oa_base = cred_area;
  440.     msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
  441.     r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]);
  442.  
  443.  
  444. #ifdef FD_SETSIZE
  445.     setsize = _rpc_dtablesize();    
  446.     maskp = (u_long *)readfds->fds_bits;
  447.     for (sock = 0; sock < setsize; sock += NFDBITS) {
  448.         for (mask = *maskp++; bit = ffs(mask); mask ^= (1 << (bit - 1))) {
  449.         /* sock has input waiting */
  450.         xprt = xports[sock + bit - 1];
  451. #else
  452.     for (sock = 0; readfds_local != 0; sock++, readfds_local >>= 1) {
  453.         if ((readfds_local & 1) != 0) {
  454.         /* sock has input waiting */
  455.         xprt = xports[sock];
  456. #endif /* def FD_SETSIZE */
  457.         /* now receive msgs from xprtprt (support batch calls) */
  458.         do {
  459.             if (SVC_RECV(xprt, &msg)) {
  460.  
  461.                 /* now find the exported program and call it */
  462.                 register struct svc_callout *s;
  463.                 enum auth_stat why;
  464.  
  465.                 r.rq_xprt = xprt;
  466.                 r.rq_prog = msg.rm_call.cb_prog;
  467.                 r.rq_vers = msg.rm_call.cb_vers;
  468.                 r.rq_proc = msg.rm_call.cb_proc;
  469.                 r.rq_cred = msg.rm_call.cb_cred;
  470.                 /* first authenticate the message */
  471.                 if ((why= _authenticate(&r, &msg)) != AUTH_OK) {
  472.                     svcerr_auth(xprt, why);
  473.                     goto call_done;
  474.                 }
  475.                 /* now match message with a registered service*/
  476.                 prog_found = FALSE;
  477.                 low_vers = 0 - 1;
  478.                 high_vers = 0;
  479.                 for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  480.                     if (s->sc_prog == r.rq_prog) {
  481.                         if (s->sc_vers == r.rq_vers) {
  482.                             (*s->sc_dispatch)(&r, xprt);
  483.                             goto call_done;
  484.                         }  /* found correct version */
  485.                         prog_found = TRUE;
  486.                         if (s->sc_vers < low_vers)
  487.                             low_vers = s->sc_vers;
  488.                         if (s->sc_vers > high_vers)
  489.                             high_vers = s->sc_vers;
  490.                     }   /* found correct program */
  491.                 }
  492.                 /*
  493.                  * if we got here, the program or version
  494.                  * is not served ...
  495.                  */
  496.                 if (prog_found)
  497.                     svcerr_progvers(xprt,
  498.                     low_vers, high_vers);
  499.                 else
  500.                      svcerr_noprog(xprt);
  501.                 /* Fall through to ... */
  502.             }
  503.         call_done:
  504.             if ((stat = SVC_STAT(xprt)) == XPRT_DIED){
  505.                 SVC_DESTROY(xprt);
  506.                 break;
  507.             }
  508.         } while (stat == XPRT_MOREREQS);
  509.         }
  510.     }
  511. }
  512.